{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6S9hJ4VbTSb-"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/timsainb/tensorflow2-generative-models/blob/master/6.0-VAE-GAN-fashion-mnist.ipynb)\n",
    "\n",
    "## VAE-GAN ([article](https://arxiv.org/abs/1512.09300)) \n",
    "VAE-GAN combines the VAE and GAN to autoencode over a latent representation of data in the generator to improve over the pixelwise error function used in autoencoders. \n",
    "\n",
    "![vae gan](https://github.com/timsainb/tensorflow2-generative-models/blob/f3360a819b5773692e943dfe181972a76b9d91bb/imgs/vaegan.png?raw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9cjmaU9fTScD"
   },
   "source": [
    "### Install packages if in colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PNgGaUToTScE"
   },
   "outputs": [],
   "source": [
    "### install necessary packages if in colab\n",
    "def run_subprocess_command(cmd):\n",
    "    process = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\n",
    "    for line in process.stdout:\n",
    "        print(line.decode().strip())\n",
    "\n",
    "\n",
    "import sys, subprocess\n",
    "\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "colab_requirements = [\n",
    "    \"pip install tf-nightly-gpu-2.0-preview==2.0.0.dev20190513\",\n",
    "    \"pip install tfp-nightly==0.7.0.dev20190508\",\n",
    "]\n",
    "if IN_COLAB:\n",
    "    for i in colab_requirements:\n",
    "        run_subprocess_command(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DE4MtOOLTScI"
   },
   "source": [
    "#### Note: to get this working on fashion MNIST without using any sort of batch normalization I added two parameters: `latent_loss_div` and `recon_loss_div`. Their purpose is just to scale the loss of the KL Divergence and the reconstruction error in order to balance the three losses in the generator (reconstruction, KL divergence, GAN). Similar to $\\beta$-VAE. In addition I balance the generator and discriminator loss by squashing the discriminator loss with a sigmoid based on how much it is beating the generator by.\n",
    "\n",
    "#### In addition - the quality of samples continues to improve well past 50 epochs - so I reccomend training for longer than I did here! I'm sure you could also find better hyperparameters to improve training speeds. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tI6r7NYqTScJ"
   },
   "source": [
    "### load packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:52:58.541506Z",
     "start_time": "2019-05-12T22:52:54.469984Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "wTGSakMtTScL",
    "outputId": "fb952c24-2ffd-4e7e-b77e-43ddf7cdd01a"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/cube/tsainbur/conda_envs/tpy3/lib/python3.6/site-packages/tqdm/autonotebook/__init__.py:14: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
      "  \" (e.g. in jupyter console)\", TqdmExperimentalWarning)\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm.autonotebook import tqdm\n",
    "%matplotlib inline\n",
    "from IPython import display\n",
    "import pandas as pd\n",
    "import tensorflow_probability as tfp\n",
    "ds = tfp.distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:52:58.547455Z",
     "start_time": "2019-05-12T22:52:58.543973Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "afLlwrbqTScQ",
    "outputId": "2e911024-7b0f-4528-f941-3f71009b21c5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0-dev20190510 0.7.0-dev20190510\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__, tfp.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AYpFTIb_TScU"
   },
   "source": [
    "### Create a fashion-MNIST dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:52:58.638637Z",
     "start_time": "2019-05-12T22:52:58.549332Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "Mu4ZvNCTTScV"
   },
   "outputs": [],
   "source": [
    "TRAIN_BUF=60000\n",
    "BATCH_SIZE=64\n",
    "TEST_BUF=10000\n",
    "DIMS = (28,28,1)\n",
    "N_TRAIN_BATCHES =int(TRAIN_BUF/BATCH_SIZE)\n",
    "N_TEST_BATCHES = int(TEST_BUF/BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:03.378562Z",
     "start_time": "2019-05-12T22:52:58.640651Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "SmK4qK_QTScX"
   },
   "outputs": [],
   "source": [
    "# load dataset\n",
    "(train_images, _), (test_images, _) = tf.keras.datasets.fashion_mnist.load_data()\n",
    "\n",
    "# split dataset\n",
    "train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype(\n",
    "    \"float32\"\n",
    ") / 255.0\n",
    "test_images = test_images.reshape(test_images.shape[0], 28, 28, 1).astype(\"float32\") / 255.0\n",
    "\n",
    "# batch datasets\n",
    "train_dataset = (\n",
    "    tf.data.Dataset.from_tensor_slices(train_images)\n",
    "    .shuffle(TRAIN_BUF)\n",
    "    .batch(BATCH_SIZE)\n",
    ")\n",
    "test_dataset = (\n",
    "    tf.data.Dataset.from_tensor_slices(test_images)\n",
    "    .shuffle(TEST_BUF)\n",
    "    .batch(BATCH_SIZE)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "swaswhSJTScZ"
   },
   "source": [
    "### Define the network as tf.keras.model object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:03.443093Z",
     "start_time": "2019-05-12T22:53:03.381042Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "yh33F1KQTSca"
   },
   "outputs": [],
   "source": [
    "class VAEGAN(tf.keras.Model):\n",
    "    \"\"\"a VAEGAN class for tensorflow\n",
    "    \n",
    "    Extends:\n",
    "        tf.keras.Model\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(VAEGAN, self).__init__()\n",
    "        self.__dict__.update(kwargs)\n",
    "\n",
    "        self.enc = tf.keras.Sequential(self.enc)\n",
    "        self.dec = tf.keras.Sequential(self.dec)\n",
    "        inputs, disc_l, outputs = self.vae_disc_function()\n",
    "        self.disc = tf.keras.Model(inputs=[inputs], outputs=[outputs, disc_l])\n",
    "\n",
    "        self.enc_optimizer = tf.keras.optimizers.Adam(self.lr_base_gen, beta_1=0.5)\n",
    "        self.dec_optimizer = tf.keras.optimizers.Adam(self.lr_base_gen, beta_1=0.5)\n",
    "        self.disc_optimizer = tf.keras.optimizers.Adam(self.get_lr_d, beta_1=0.5)\n",
    "\n",
    "    def encode(self, x):\n",
    "        mu, sigma = tf.split(self.enc(x), num_or_size_splits=2, axis=1)\n",
    "        return mu, sigma\n",
    "\n",
    "    def dist_encode(self, x):\n",
    "        mu, sigma = self.encode(x)\n",
    "        return ds.MultivariateNormalDiag(loc=mu, scale_diag=sigma)\n",
    "\n",
    "    def get_lr_d(self):\n",
    "        return self.lr_base_disc * self.D_prop\n",
    "\n",
    "    def decode(self, z):\n",
    "        return self.dec(z)\n",
    "\n",
    "    def discriminate(self, x):\n",
    "        return self.disc(x)\n",
    "\n",
    "    def reconstruct(self, x):\n",
    "        mean, _ = self.encode(x)\n",
    "        return self.decode(mean)\n",
    "\n",
    "    def reparameterize(self, mean, logvar):\n",
    "        eps = tf.random.normal(shape=mean.shape)\n",
    "        return eps * tf.exp(logvar * 0.5) + mean\n",
    "\n",
    "    # @tf.function\n",
    "    def compute_loss(self, x):\n",
    "        # pass through network\n",
    "        q_z = self.dist_encode(x)\n",
    "        z = q_z.sample()\n",
    "        p_z = ds.MultivariateNormalDiag(\n",
    "            loc=[0.0] * z.shape[-1], scale_diag=[1.0] * z.shape[-1]\n",
    "        )\n",
    "        xg = self.decode(z)\n",
    "        z_samp = tf.random.normal([x.shape[0], 1, 1, z.shape[-1]])\n",
    "        xg_samp = self.decode(z_samp)\n",
    "        d_xg, ld_xg = self.discriminate(xg)\n",
    "        d_x, ld_x = self.discriminate(x)\n",
    "        d_xg_samp, ld_xg_samp = self.discriminate(xg_samp)\n",
    "\n",
    "        # GAN losses\n",
    "        disc_real_loss = gan_loss(logits=d_x, is_real=True)\n",
    "        disc_fake_loss = gan_loss(logits=d_xg_samp, is_real=False)\n",
    "        gen_fake_loss = gan_loss(logits=d_xg_samp, is_real=True)\n",
    "\n",
    "        discrim_layer_recon_loss = (\n",
    "            tf.reduce_mean(tf.reduce_mean(tf.math.square(ld_x - ld_xg), axis=0))\n",
    "            / self.recon_loss_div\n",
    "        )\n",
    "\n",
    "        self.D_prop = sigmoid(\n",
    "            disc_fake_loss - gen_fake_loss, shift=0.0, mult=self.sig_mult\n",
    "        )\n",
    "\n",
    "        kl_div = ds.kl_divergence(q_z, p_z)\n",
    "        latent_loss = tf.reduce_mean(tf.maximum(kl_div, 0)) / self.latent_loss_div\n",
    "\n",
    "        return (\n",
    "            self.D_prop,\n",
    "            latent_loss,\n",
    "            discrim_layer_recon_loss,\n",
    "            gen_fake_loss,\n",
    "            disc_fake_loss,\n",
    "            disc_real_loss,\n",
    "        )\n",
    "\n",
    "    # @tf.function\n",
    "    def compute_gradients(self, x):\n",
    "        with tf.GradientTape() as enc_tape, tf.GradientTape() as dec_tape, tf.GradientTape() as disc_tape:\n",
    "            (\n",
    "                _,\n",
    "                latent_loss,\n",
    "                discrim_layer_recon_loss,\n",
    "                gen_fake_loss,\n",
    "                disc_fake_loss,\n",
    "                disc_real_loss,\n",
    "            ) = self.compute_loss(x)\n",
    "\n",
    "            enc_loss = latent_loss + discrim_layer_recon_loss\n",
    "            dec_loss = gen_fake_loss + discrim_layer_recon_loss\n",
    "            disc_loss = disc_fake_loss + disc_real_loss\n",
    "\n",
    "        enc_gradients = enc_tape.gradient(enc_loss, self.enc.trainable_variables)\n",
    "        dec_gradients = dec_tape.gradient(dec_loss, self.dec.trainable_variables)\n",
    "        disc_gradients = disc_tape.gradient(disc_loss, self.disc.trainable_variables)\n",
    "\n",
    "        return enc_gradients, dec_gradients, disc_gradients\n",
    "\n",
    "    @tf.function\n",
    "    def apply_gradients(self, enc_gradients, dec_gradients, disc_gradients):\n",
    "        self.enc_optimizer.apply_gradients(\n",
    "            zip(enc_gradients, self.enc.trainable_variables)\n",
    "        )\n",
    "        self.dec_optimizer.apply_gradients(\n",
    "            zip(dec_gradients, self.dec.trainable_variables)\n",
    "        )\n",
    "        self.disc_optimizer.apply_gradients(\n",
    "            zip(disc_gradients, self.disc.trainable_variables)\n",
    "        )\n",
    "\n",
    "    def train(self, x):\n",
    "        enc_gradients, dec_gradients, disc_gradients = self.compute_gradients(x)\n",
    "        self.apply_gradients(enc_gradients, dec_gradients, disc_gradients)\n",
    "\n",
    "\n",
    "def gan_loss(logits, is_real=True):\n",
    "    \"\"\"Computes standard gan loss between logits and labels\n",
    "                \n",
    "        Arguments:\n",
    "            logits {[type]} -- output of discriminator\n",
    "        \n",
    "        Keyword Arguments:\n",
    "            isreal {bool} -- whether labels should be 0 (fake) or 1 (real) (default: {True})\n",
    "        \"\"\"\n",
    "    if is_real:\n",
    "        labels = tf.ones_like(logits)\n",
    "    else:\n",
    "        labels = tf.zeros_like(logits)\n",
    "\n",
    "    return tf.compat.v1.losses.sigmoid_cross_entropy(\n",
    "        multi_class_labels=labels, logits=logits\n",
    "    )\n",
    "\n",
    "\n",
    "def sigmoid(x, shift=0.0, mult=20):\n",
    "    \"\"\" squashes a value with a sigmoid\n",
    "    \"\"\"\n",
    "    return tf.constant(1.0) / (\n",
    "        tf.constant(1.0) + tf.exp(-tf.constant(1.0) * (x * mult))\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EtWizbufTScc"
   },
   "source": [
    "### Define the network architecture\n",
    "- GAIA has an autoencoder as its generator, and a UNET as its descriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:03.581122Z",
     "start_time": "2019-05-12T22:53:03.445100Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "2pMgFfFETSce"
   },
   "outputs": [],
   "source": [
    "N_Z = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:03.704579Z",
     "start_time": "2019-05-12T22:53:03.585028Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "k9SohQvnTSch"
   },
   "outputs": [],
   "source": [
    "encoder = [\n",
    "    tf.keras.layers.InputLayer(input_shape=DIMS),\n",
    "    tf.keras.layers.Conv2D(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2D(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(units=N_Z*2),\n",
    "]\n",
    "\n",
    "decoder = [\n",
    "    tf.keras.layers.Dense(units=7 * 7 * 64, activation=\"relu\"),\n",
    "    tf.keras.layers.Reshape(target_shape=(7, 7, 64)),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=1, kernel_size=3, strides=(1, 1), padding=\"SAME\", activation=\"sigmoid\"\n",
    "    ),\n",
    "]\n",
    "\n",
    "def vaegan_discrim():\n",
    "    inputs = tf.keras.layers.Input(shape=(28, 28, 1))\n",
    "    conv1 = tf.keras.layers.Conv2D(\n",
    "                filters=32, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "            )(inputs)\n",
    "    conv2 = tf.keras.layers.Conv2D(\n",
    "                filters=64, kernel_size=3, strides=(2, 2), activation=\"relu\"\n",
    "            )(conv1)\n",
    "    flatten = tf.keras.layers.Flatten()(conv2)\n",
    "    lastlayer = tf.keras.layers.Dense(units=512, activation=\"relu\")(flatten)\n",
    "    outputs = tf.keras.layers.Dense(units=1, activation = None)(lastlayer)\n",
    "    return inputs, lastlayer, outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T18:40:40.306731Z",
     "start_time": "2019-05-10T18:40:40.292930Z"
    },
    "colab_type": "text",
    "id": "BCp-NE8HTSck"
   },
   "source": [
    "### Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:04.748386Z",
     "start_time": "2019-05-12T22:53:03.707925Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "HQAi3QxwTScl"
   },
   "outputs": [],
   "source": [
    "# the unet function \n",
    "gen_optimizer = tf.keras.optimizers.Adam(1e-3, beta_1=0.5)\n",
    "disc_optimizer = tf.keras.optimizers.RMSprop(1e-3)\n",
    "    \n",
    "# model\n",
    "model = VAEGAN(\n",
    "    enc = encoder,\n",
    "    dec = decoder,\n",
    "    vae_disc_function = vaegan_discrim,\n",
    "    lr_base_gen = 1e-3, # \n",
    "    lr_base_disc = 1e-4, # the discriminator's job is easier than the generators so make the learning rate lower\n",
    "    latent_loss_div=1, # this variable will depend on your dataset - choose a number that will bring your latent loss to ~1-10\n",
    "    sig_mult = 10, # how binary the discriminator's learning rate is shifted (we squash it with a sigmoid)\n",
    "    recon_loss_div = .001, # this variable will depend on your dataset - choose a number that will bring your latent loss to ~1-10\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kaj9-dcUTSco"
   },
   "source": [
    "### Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:05.434725Z",
     "start_time": "2019-05-12T22:53:04.752033Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "SsVWJ-PXTScp"
   },
   "outputs": [],
   "source": [
    "# exampled data for plotting results\n",
    "example_data = next(iter(train_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:07.958473Z",
     "start_time": "2019-05-12T22:53:05.437136Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "FbSd4aD2TScr"
   },
   "outputs": [],
   "source": [
    "model.train(example_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:07.991485Z",
     "start_time": "2019-05-12T22:53:07.962885Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "ixWnqbggTSct"
   },
   "outputs": [],
   "source": [
    "def plot_reconstruction(model, example_data, nex=8, zm=2):\n",
    "\n",
    "    example_data_reconstructed = model.reconstruct(example_data)\n",
    "    samples = model.decode(tf.random.normal(shape=(BATCH_SIZE, N_Z)))\n",
    "    fig, axs = plt.subplots(ncols=nex, nrows=3, figsize=(zm * nex, zm * 3))\n",
    "    for axi, (dat, lab) in enumerate(\n",
    "        zip(\n",
    "            [example_data, example_data_reconstructed, samples],\n",
    "            [\"data\", \"data recon\", \"samples\"],\n",
    "        )\n",
    "    ):\n",
    "        for ex in range(nex):\n",
    "            axs[axi, ex].matshow(\n",
    "                dat.numpy()[ex].squeeze(), cmap=plt.cm.Greys, vmin=0, vmax=1\n",
    "            )\n",
    "            axs[axi, ex].axes.get_xaxis().set_ticks([])\n",
    "            axs[axi, ex].axes.get_yaxis().set_ticks([])\n",
    "        axs[axi, 0].set_ylabel(lab)\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "def plot_losses(losses):\n",
    "    fig, axs =plt.subplots(ncols = 4, nrows = 1, figsize= (16,4))\n",
    "    axs[0].plot(losses.latent_loss.values, label = 'latent_loss')\n",
    "    axs[1].plot(losses.discrim_layer_recon_loss.values, label = 'discrim_layer_recon_loss')\n",
    "    axs[2].plot(losses.disc_real_loss.values, label = 'disc_real_loss')\n",
    "    axs[2].plot(losses.disc_fake_loss.values, label = 'disc_fake_loss')\n",
    "    axs[2].plot(losses.gen_fake_loss.values, label = 'gen_fake_loss')\n",
    "    axs[3].plot(losses.d_prop.values, label = 'd_prop')\n",
    "\n",
    "    for ax in axs.flatten():\n",
    "        ax.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T22:53:08.132405Z",
     "start_time": "2019-05-12T22:53:07.995313Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "VwHuGzHcTScw"
   },
   "outputs": [],
   "source": [
    "# a pandas dataframe to save the loss information to\n",
    "losses = pd.DataFrame(columns=[\n",
    "    'd_prop',\n",
    "    'latent_loss',\n",
    "    'discrim_layer_recon_loss',\n",
    "    'gen_fake_loss',\n",
    "    'disc_fake_loss',\n",
    "    'disc_real_loss',\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-13T06:18:45.251515Z",
     "start_time": "2019-05-12T22:53:08.139350Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "o4jBsKGBTScy",
    "outputId": "ff5895fa-32ce-4050-a61b-9a733259f071"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 199\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 24 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_epochs = 200\n",
    "for epoch in range(n_epochs):\n",
    "    # train\n",
    "    for batch, train_x in tqdm(\n",
    "        zip(range(N_TRAIN_BATCHES), train_dataset), total=N_TRAIN_BATCHES\n",
    "    ):\n",
    "        model.train(train_x)\n",
    "    # test on holdout\n",
    "    loss = []\n",
    "    for batch, test_x in tqdm(\n",
    "        zip(range(N_TEST_BATCHES), train_dataset), total=N_TEST_BATCHES\n",
    "    ):\n",
    "        loss.append(model.compute_loss(train_x))\n",
    "    losses.loc[len(losses)] = np.mean(loss, axis=0)\n",
    "    # plot results\n",
    "    display.clear_output()\n",
    "    print(\n",
    "        \"Epoch: {}\".format(epoch)\n",
    "    )\n",
    "    plot_reconstruction(model, example_data)\n",
    "    plot_losses(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AOfetB3bTSc2"
   },
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "6.0-VAE-GAN-fashion-mnist.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
